// dataFlattener.js
class DataFlattener {
  /**
   * 将试验数据转换为扁平化的 key:value 格式（使用下划线表示数组索引）
   */
  static flattenTestData(testData) {
    const flatMap = {};
    
    // 解析基本信息
    if (testData.basicInfo) {
      this.flattenBasicInfo(testData.basicInfo, flatMap);
    }
    
    // 解析项目信息
    this.flattenProjectInfo(testData, flatMap);
    
    // 解析测试数据
    if (testData.testData && testData.testData.groups) {
      this.flattenGroups(testData.testData.groups, flatMap);
    }
    
    return flatMap;
  }

  /**
   * 解析基本信息
   */
  static flattenBasicInfo(basicInfo, flatMap) {
    Object.keys(basicInfo).forEach(key => {
      flatMap[key] = basicInfo[key];
    });
  }

  /**
   * 解析项目信息
   */
  static flattenProjectInfo(testData, flatMap) {
    flatMap.projectId = testData.projectId;
    flatMap.projectName = testData.projectName;
    flatMap.standardCode = testData.standardCode;
    flatMap.timestamp = testData.timestamp;
  }

  /**
   * 解析参数组
   */
  static flattenGroups(groups, flatMap) {
    groups.forEach(group => {
      // 解析组内参数
      if (group.params) {
        this.flattenParams(group.params, flatMap);
      }
      
      // 解析动态表格数据
      if (group.rows) {
        this.flattenTableRows(group.rows, flatMap);
      }
    });
  }

  /**
   * 解析普通参数
   */
  static flattenParams(params, flatMap) {
    Object.keys(params).forEach(paramCode => {
      const value = params[paramCode];
      
      if (Array.isArray(value)) {
        // 处理数组参数 - 使用下划线表示索引，从1开始
        this.flattenParamArray(value, flatMap, paramCode);
      } else if (value && typeof value === 'object' && value.value !== undefined) {
        // 处理单值参数对象
        flatMap[paramCode] = value.value;
      } else {
        // 直接值
        flatMap[paramCode] = value;
      }
    });
  }

  /**
   * 解析参数数组（使用下划线表示索引，从1开始）
   */
  static flattenParamArray(paramArray, flatMap, paramCode) {
    paramArray.forEach((item, index) => {
      // 使用下划线表示数组索引：a_qrvp_1
      const itemKey = `${paramCode}_${index + 1}`;
      
      if (item && typeof item === 'object' && item.value !== undefined) {
        flatMap[itemKey] = item.value;
      } else {
        flatMap[itemKey] = item;
      }
    });
  }

  /**
   * 解析动态表格行数据（使用下划线表示索引，从1开始）
   */
  static flattenTableRows(rows, flatMap) {
    rows.forEach((row, rowIndex) => {
      Object.keys(row).forEach(paramCode => {
        const value = row[paramCode];
        // 使用下划线表示行索引：row_1
        const rowKey = `row_${rowIndex + 1}`;
        
        if (Array.isArray(value)) {
          // 处理表格中的数组参数
          value.forEach((item, colIndex) => {
            // 使用下划线表示列索引：row_1.a_cpih_1
            const itemKey = `${rowKey}.${paramCode}_${colIndex + 1}`;
            
            if (item && typeof item === 'object' && item.value !== undefined) {
              flatMap[itemKey] = item.value;
            } else {
              flatMap[itemKey] = item;
            }
          });
        } else if (value && typeof value === 'object' && value.value !== undefined) {
          // 处理表格中的单值参数：row_1.a_tssd
          const itemKey = `${rowKey}.${paramCode}`;
          flatMap[itemKey] = value.value;
        } else {
          const itemKey = `${rowKey}.${paramCode}`;
          flatMap[itemKey] = value;
        }
      });
    });
  }

  /**
   * 将下划线格式转换为方括号格式（如果需要）
   */
  static convertToBracketFormat(code) {
    // 将 row_1.a_bcde_1 转换为 row[1].a_bcde[1]
    return code.replace(/row_(\d+)/g, 'row[$1]')
              .replace(/\.([a-zA-Z0-9_]+)_(\d+)(?=\.|$)/g, '.$1[$2]')
              .replace(/([a-zA-Z0-9_]+)_(\d+)$/g, '$1[$2]');
  }

  /**
   * 将方括号格式转换为下划线格式（如果需要）
   */
  static convertToUnderscoreFormat(code) {
    // 将 row[1].a_bcde[1] 转换为 row_1.a_bcde_1
    return code.replace(/row\[(\d+)\]/g, 'row_$1')
              .replace(/\.([a-zA-Z0-9_]+)\[(\d+)\](?=\.|$)/g, '.$1_$2')
              .replace(/([a-zA-Z0-9_]+)\[(\d+)\]$/g, '$1_$2');
  }

  /**
   * 打印扁平化数据（用于调试）
   */
  static printFlatData(flatMap) {
    console.log('=== 扁平化数据（下划线格式）===');
    Object.keys(flatMap)
      .sort()
      .forEach(key => {
        console.log(`${key}: ${flatMap[key]}`);
      });
    console.log(`=== 总计 ${Object.keys(flatMap).length} 个参数 ===`);
  }
}

export default DataFlattener;